home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / ddj0897.zip / DYN401.ZIP / class / shortary.c < prev    next >
C/C++ Source or Header  |  1997-04-16  |  7KB  |  320 lines
  1.  
  2.  
  3. /*  Copyright (c) 1993-1996 Algorithms Corporation  */
  4. /*  All rights reserved.  */
  5.  
  6.  
  7.  
  8.  
  9. /*  This file automatically generated by dpp - do not edit  */
  10.  
  11. #define    DPP_STRATEGY    2
  12. #define    DPP_FASTWIDE    0
  13.  
  14.  
  15.  
  16. #line 18 "shortary.d"
  17. #include "array1.h" 
  18.  
  19. #define    CLASS    ShortArray_c
  20. #define    ivType    ShortArray_iv_t
  21.  
  22. #include "generics.h"
  23.  
  24. object    ShortArray_c;
  25.  
  26.  
  27. #line 26 "shortary.d"
  28. #define TYPE short 
  29.  
  30.  
  31. static gIndex_t _index; 
  32.  
  33.  
  34. cvmeth objrtn ShortArray_cvm_vNew(object self, va_list _rest_)
  35. { 
  36.     unsigned rank = va_arg(_rest_, unsigned);
  37.  
  38. #line 34 "shortary.d"
  39.     static gNewArray_t cnew = NULL; 
  40.     MAKE_REST(rank); 
  41.  
  42.     if (!cnew) 
  43.         cnew = cmcPointer(Array, gNewArray); 
  44.     return cnew(self, AT_SHRT, rank, _rest_); 
  45. } 
  46.  
  47. #line 48 "shortary.c"
  48.  
  49. static    objrtn    ShortArray_cfm_vNew(object self, ...)
  50. {
  51.     va_list    _rest_;
  52.     va_start(_rest_, self);
  53.     return ShortArray_cvm_vNew(self, _rest_);
  54. }
  55.  
  56.  
  57.  
  58. #line 42 "shortary.d"
  59. ivmeth char ShortArray_ivm_vCharValue(object self, va_list _rest_)
  60. { 
  61.     MAKE_REST(self); 
  62.     return (char) *((TYPE *) _index(self, _rest_)); 
  63. } 
  64.  
  65. #line 66 "shortary.c"
  66.  
  67. static    char    ShortArray_ifm_vCharValue(object self, ...)
  68. {
  69.     va_list    _rest_;
  70.     va_start(_rest_, self);
  71.     return ShortArray_ivm_vCharValue(self, _rest_);
  72. }
  73.  
  74.  
  75.  
  76. #line 48 "shortary.d"
  77. ivmeth short ShortArray_ivm_vShortValue(object self, va_list _rest_)
  78. { 
  79.     MAKE_REST(self); 
  80.     return (short) *((TYPE *) _index(self, _rest_)); 
  81. } 
  82.  
  83. #line 84 "shortary.c"
  84.  
  85. static    short    ShortArray_ifm_vShortValue(object self, ...)
  86. {
  87.     va_list    _rest_;
  88.     va_start(_rest_, self);
  89.     return ShortArray_ivm_vShortValue(self, _rest_);
  90. }
  91.  
  92.  
  93.  
  94. #line 54 "shortary.d"
  95. ivmeth unsigned short ShortArray_ivm_vUnsignedShortValue(object self, va_list _rest_)
  96. { 
  97.     MAKE_REST(self); 
  98.     return (unsigned short) *((TYPE *) _index(self, _rest_)); 
  99. } 
  100.  
  101. #line 102 "shortary.c"
  102.  
  103. static    unsigned short    ShortArray_ifm_vUnsignedShortValue(object self, ...)
  104. {
  105.     va_list    _rest_;
  106.     va_start(_rest_, self);
  107.     return ShortArray_ivm_vUnsignedShortValue(self, _rest_);
  108. }
  109.  
  110.  
  111.  
  112. #line 60 "shortary.d"
  113. ivmeth long ShortArray_ivm_vLongValue(object self, va_list _rest_)
  114. { 
  115.     MAKE_REST(self); 
  116.     return (long) *((TYPE *) _index(self, _rest_)); 
  117. } 
  118.  
  119. #line 120 "shortary.c"
  120.  
  121. static    long    ShortArray_ifm_vLongValue(object self, ...)
  122. {
  123.     va_list    _rest_;
  124.     va_start(_rest_, self);
  125.     return ShortArray_ivm_vLongValue(self, _rest_);
  126. }
  127.  
  128.  
  129.  
  130. #line 66 "shortary.d"
  131. ivmeth double ShortArray_ivm_vDoubleValue(object self, va_list _rest_)
  132. { 
  133.     MAKE_REST(self); 
  134.     return (double) *((TYPE *) _index(self, _rest_)); 
  135. } 
  136.  
  137. #line 138 "shortary.c"
  138.  
  139. static    double    ShortArray_ifm_vDoubleValue(object self, ...)
  140. {
  141.     va_list    _rest_;
  142.     va_start(_rest_, self);
  143.     return ShortArray_ivm_vDoubleValue(self, _rest_);
  144. }
  145.  
  146.  
  147.  
  148. #line 72 "shortary.d"
  149. ivmeth objrtn ShortArray_ivm_vChangeValue(object self, va_list _rest_)
  150. { object val = va_arg(_rest_, object);
  151.     MAKE_REST(val); 
  152.     ChkArg(val, 2); 
  153.     *((TYPE *) _index(self, _rest_)) = gShortValue(val); 
  154.     return self; 
  155. } 
  156.  
  157. #line 158 "shortary.c"
  158.  
  159. static    objrtn    ShortArray_ifm_vChangeValue(object self, ...)
  160. {
  161.     va_list    _rest_;
  162.     va_start(_rest_, self);
  163.     return ShortArray_ivm_vChangeValue(self, _rest_);
  164. }
  165.  
  166.  
  167.  
  168. #line 80 "shortary.d"
  169. ivmeth objrtn ShortArray_ivm_vChangeCharValue(object self, va_list _rest_)
  170. { int val = va_arg(_rest_, int);
  171.     MAKE_REST(val); 
  172.     *((TYPE *) _index(self, _rest_)) = (TYPE) val; 
  173.     return self; 
  174. } 
  175.  
  176. #line 177 "shortary.c"
  177.  
  178. static    objrtn    ShortArray_ifm_vChangeCharValue(object self, ...)
  179. {
  180.     va_list    _rest_;
  181.     va_start(_rest_, self);
  182.     return ShortArray_ivm_vChangeCharValue(self, _rest_);
  183. }
  184.  
  185.  
  186.  
  187. #line 87 "shortary.d"
  188. ivmeth objrtn ShortArray_ivm_vChangeShortValue(object self, va_list _rest_)
  189. { int val = va_arg(_rest_, int);
  190.     MAKE_REST(val); 
  191.     *((TYPE *) _index(self, _rest_)) = (TYPE) val; 
  192.     return self; 
  193. } 
  194.  
  195. #line 196 "shortary.c"
  196.  
  197. static    objrtn    ShortArray_ifm_vChangeShortValue(object self, ...)
  198. {
  199.     va_list    _rest_;
  200.     va_start(_rest_, self);
  201.     return ShortArray_ivm_vChangeShortValue(self, _rest_);
  202. }
  203.  
  204.  
  205.  
  206. #line 94 "shortary.d"
  207. ivmeth objrtn ShortArray_ivm_vChangeUShortValue(object self, va_list _rest_)
  208. { unsigned val = va_arg(_rest_, unsigned);
  209.     MAKE_REST(val); 
  210.     *((TYPE *) _index(self, _rest_)) = (TYPE) val; 
  211.     return self; 
  212. } 
  213.  
  214. #line 215 "shortary.c"
  215.  
  216. static    objrtn    ShortArray_ifm_vChangeUShortValue(object self, ...)
  217. {
  218.     va_list    _rest_;
  219.     va_start(_rest_, self);
  220.     return ShortArray_ivm_vChangeUShortValue(self, _rest_);
  221. }
  222.  
  223.  
  224.  
  225. #line 101 "shortary.d"
  226. ivmeth objrtn ShortArray_ivm_vChangeLongValue(object self, va_list _rest_)
  227. { long val = va_arg(_rest_, long);
  228.     MAKE_REST(val); 
  229.     *((TYPE *) _index(self, _rest_)) = (TYPE) val; 
  230.     return self; 
  231. } 
  232.  
  233. #line 234 "shortary.c"
  234.  
  235. static    objrtn    ShortArray_ifm_vChangeLongValue(object self, ...)
  236. {
  237.     va_list    _rest_;
  238.     va_start(_rest_, self);
  239.     return ShortArray_ivm_vChangeLongValue(self, _rest_);
  240. }
  241.  
  242.  
  243.  
  244. #line 108 "shortary.d"
  245. ivmeth objrtn ShortArray_ivm_vChangeDoubleValue(object self, va_list _rest_)
  246. { double val = va_arg(_rest_, double);
  247.     MAKE_REST(val); 
  248.     *((TYPE *) _index(self, _rest_)) = (TYPE) val; 
  249.     return self; 
  250. } 
  251.  
  252. #line 253 "shortary.c"
  253.  
  254. static    objrtn    ShortArray_ifm_vChangeDoubleValue(object self, ...)
  255. {
  256.     va_list    _rest_;
  257.     va_start(_rest_, self);
  258.     return ShortArray_ivm_vChangeDoubleValue(self, _rest_);
  259. }
  260.  
  261.  
  262. #line 115 "shortary.d"
  263. static void init_class(void) 
  264. { 
  265.     _index = imcPointer(Array, gIndex); 
  266. } 
  267.  
  268. #line 269 "shortary.c"
  269.  
  270. objrtn    ShortArray_initialize(void)
  271. {
  272.     static  CRITICALSECTION  cs;
  273.     static  int volatile once = 0;
  274.  
  275.     ENTERCRITICALSECTION(_CI_CS_);
  276.     if (!once) {
  277.         INITIALIZECRITICALSECTION(cs);
  278.         once = 1;
  279.     }
  280.     LEAVECRITICALSECTION(_CI_CS_);
  281.  
  282.     ENTERCRITICALSECTION(cs);
  283.  
  284.     if (ShortArray_c) {
  285.         LEAVECRITICALSECTION(cs);
  286.         return ShortArray_c;
  287.     }
  288.     INHIBIT_THREADER;
  289.     NumberArray_initialize();
  290.     if (ShortArray_c)  {
  291.         ENABLE_THREADER;
  292.         LEAVECRITICALSECTION(cs);
  293.         return ShortArray_c;
  294.     }
  295.     ShortArray_c = gNewClass(Class, "ShortArray", 0, 0, NumberArray, END);
  296.     cvMethodFor(ShortArray, vNew, ShortArray_cvm_vNew, ShortArray_cfm_vNew);
  297.     ivMethodFor(ShortArray, vCharValue, ShortArray_ivm_vCharValue, ShortArray_ifm_vCharValue);
  298.     ivMethodFor(ShortArray, vChangeUShortValue, ShortArray_ivm_vChangeUShortValue, ShortArray_ifm_vChangeUShortValue);
  299.     ivMethodFor(ShortArray, vChangeValue, ShortArray_ivm_vChangeValue, ShortArray_ifm_vChangeValue);
  300.     ivMethodFor(ShortArray, vLongValue, ShortArray_ivm_vLongValue, ShortArray_ifm_vLongValue);
  301.     ivMethodFor(ShortArray, vChangeCharValue, ShortArray_ivm_vChangeCharValue, ShortArray_ifm_vChangeCharValue);
  302.     ivMethodFor(ShortArray, vUnsignedShortValue, ShortArray_ivm_vUnsignedShortValue, ShortArray_ifm_vUnsignedShortValue);
  303.     ivMethodFor(ShortArray, vChangeDoubleValue, ShortArray_ivm_vChangeDoubleValue, ShortArray_ifm_vChangeDoubleValue);
  304.     ivMethodFor(ShortArray, vDoubleValue, ShortArray_ivm_vDoubleValue, ShortArray_ifm_vDoubleValue);
  305.     ivMethodFor(ShortArray, vChangeShortValue, ShortArray_ivm_vChangeShortValue, ShortArray_ifm_vChangeShortValue);
  306.     ivMethodFor(ShortArray, vChangeLongValue, ShortArray_ivm_vChangeLongValue, ShortArray_ifm_vChangeLongValue);
  307.     ivMethodFor(ShortArray, vShortValue, ShortArray_ivm_vShortValue, ShortArray_ifm_vShortValue);
  308.  
  309.     init_class();
  310.  
  311.     ENABLE_THREADER;
  312.  
  313.     LEAVECRITICALSECTION(cs);
  314.  
  315.     return ShortArray_c;
  316. }
  317.  
  318.  
  319.  
  320.